In OCL (Object Constraint Language), the `if then else endif` construct is used for conditional expressions, similar to many programming languages. It allows you to specify conditions and execute different expressions based on the evaluation of those conditions.

Here's how it works:

• if: It begins with the `if` keyword, followed by a condition that evaluates to a Boolean value. If this condition is true, the subsequent expression(s) will be executed
• then: After the condition, there's the `then` keyword, which indicates the expression(s) to be executed if the condition is true.
• else: Optionally, you can include an `else` keyword, followed by an expression(s). If the condition in the `if` statement is false, the expression(s) after `else` will be executed.
• endif: Finally, the `endif` keyword is used to mark the end of the conditional block.

Regarding your question about return types, in most programming languages including OCL, it's required that both expressions (the ones following `then` and `else`) have return types that are either the same or have a common superclass. This requirement ensures that the overall expression maintains consistency in its type across all possible execution paths.

Consider the following example in OCL:

if condition then
  expression1
else
  expression2
endif

In this example, `expression1` and `expression2` should have return types that are either the same or have a common superclass. This is because the result of the entire `if then else endif` construct should be well-defined, regardless of which branch is executed. If the return types were not compatible, it would lead to ambiguity and potential runtime errors.

For instance, if `expression1` returns an integer and `expression2` returns a string, it would be unclear what the overall return type of the `if then else endif` construct should be. By requiring compatible return types, OCL ensures type safety and clarity in expressions.